#pragma once
#include <iostream>

//#include "Model/Data_Definition/Model_Base.h"
#include "Media/Sync/sync.h"
#include "Media/Decoder/AudioDecoder.h"
#include "Media/Decoder/VideoDecoder.h"
#include "Media/Decoder/BaseDecoder.h"
#include "DesignPattern/ObserverVisitor.h"
#include "Data/AVPacket/AVPacketManager.h"
#include "DesignPattern/DataObserver.h" // 包含 DataObserver.h
#include "DesignPattern/DecoderThread.h"
#include "FileMangent/fileMangent.h"
#if __cplusplus >= 20202L
#include <barrier>
#include <semaphore>
#endif
class PlayMangent : public ISubject
{
public:
    static PlayMangent& get_instance()
    {
        static PlayMangent instance;
        return instance;
    }
    ~PlayMangent();
    PlayMangent(const PlayMangent& other) = delete;
    PlayMangent& operator=(const PlayMangent& other) = delete;
/********************************************************************************************************************************************/
    enum PlaybackSpeed {
        SPEED_1X,
        SPEED_1_5X,
        SPEED_2X,
        SPEED_5X,
        SPEED_10X
    };
    constexpr const char* playStatusToString(PlayStatus type) {
        switch (type) {
            case PlayStatus::IDLING:
                return "IDLING";
            case PlayStatus::PLAYING:
                return "PLAYING";
            case PlayStatus::PAUSED:
                return "PAUSED";
            case PlayStatus::STOPPED:
                return "STOPPED";
            case PlayStatus::BUSY:
                return "BUSY";
            default:
                return "UNKNOWN";
        }
        return nullptr;
    }
/********************************************************************************************************************************************/
    int status(){ return m_play_status; }
    // 初始化 PlayManager，包括初始化解码器和同步类。
    bool init();
    // 播放音视频。
    bool play();
    // 暂停播放。
    bool pause();
    // 停止播放。
    bool stop();

    //create function play previous
    bool play_previous();
    //create function play next
    bool play_next();

    bool changedPlaybackspeed(float seed);//改变播放速度
    bool addfile(const std::string & );//调用文件管理器添加文件
/********************************************************************************************************************************************/
    double playbackRate(){
        return m_currentplaybackRate;
    }
    // 获取当前播放速度倍数。
 //   PlaybackSpeed getPlaybackSpeed() const;

    // 缓存视频。
    void cacheVideo(const std::string& videoPath);

    void setVariableSpeed(bool enabled, double minSpeed, double maxSpeed){
        m_variableSpeedEnabled = enabled;
        m_minSpeed = minSpeed;
        m_maxSpeed = maxSpeed;

        // 如果启用了变速播放功能，则将当前播放速度限制在 minSpeed 和 maxSpeed 范围内
        if (m_variableSpeedEnabled)
        {
            double speed = this->playbackRate();
            if (speed < m_minSpeed) {
                speed = m_minSpeed;
            } else if (speed > m_maxSpeed) {
                speed = m_maxSpeed;
            }
        //    this->setPlaybackRate(speed);
        }
    }
        std::shared_ptr<VideoDecoder> & getvideo_decoder(){
          return m_video_decoder;
    }
    void registerFileMangent() {
        observers_.push_back(FileMangent::get_instance_ptr());
    }
/********************************************************************************************************************************************/
     //create  registerObserver
    void registerObserver(std::shared_ptr<Observer> observer) override {
            observers_.push_back(observer);
            //print observer size
            std::cout <<"observer size: "<<observers_.size()<<std::endl;
     }
     void removeObserver(std::shared_ptr<Observer> observer) override {
        observers_.erase(std::remove(observers_.begin(), observers_.end(), observer), observers_.end());
     }

     void notifyObservers(ObserverVisitor& visitor) override{
      //   std::pair<AVFormatContextWrapper::AVCodecContextPtr, AVFormatContextWrapper::AVCodecContextPtr> data = std::make_pair(audio_codec_context_, video_codec_context_);
         for (const auto& observer : observers_) {
             // 针对 DataObserver 类型
             if (auto dataObserver = dynamic_cast<DataObserver*>(observer.get())) {
                  (void)dataObserver;
          //       dataObserver->accept(visitor, this,data);
             }
             // 针对 NoDataObserver 类型
             else if (auto noDataObserver = dynamic_cast<NoDataObserver*>(observer.get())) {
                 noDataObserver->accept(visitor, this);
             }
         }
     }

     void notifyPlaybackStarted() override {
         for (const auto& observer : observers_) {
             observer->onPlaybackStarted();
         }
     }

     void notifyPlaybackStopped() override {
         for (const auto& observer : observers_) {
             observer->onPlaybackStopped();
         }
     }


/********************************************************************************************************************************************/
private:
    PlayMangent();
    int main_play_func(const FileInfo& fileinfo);
    void playVideo(int&);
    void playAudio();
    std::shared_ptr<std::thread> m_playback_thread;
    AVPacketManager m_packet_manager;
    std::atomic<bool> m_playback_running{false};

    void playback_thread_func();
    // 以下函数用于处理解码和同步类的事件。
    void onAudioDecoded();
    void onVideoDecoded();
    void onAVSync();

    std::shared_ptr<AudioDecoder> m_audio_decoder; // 音频解码器。
    std::shared_ptr<VideoDecoder> m_video_decoder; // 视频解码器
    std::unique_ptr<AVSync> m_av_sync;             // 音视频同步类。

    std::mutex mutex_thread;
    std::condition_variable m_cond_var;
    std::mutex m_sync_mutex;                    // 互斥锁，用于保护idff

    std::atomic<bool> m_signal_received;
    PlayStatus m_play_status;    // 当前播放状态。

    double m_minSpeed;
    double m_maxSpeed;

    bool m_currentplaybackRate;
    bool m_variableSpeedEnabled;
//    PlaybackSpeed m_playback_speed;                // 当前播放速度倍数。
#if __cplusplus >= 202002L
    std::counting_semaphore<1> sema;  // 信号量
    std::counting_semaphore<2> sem_decoder;  // 信号量
#endif
    // 回调函数，处理同步状态变化
    void on_sync_status_changed(AVSync::SyncStatus status);
    bool check_codec_ctx(AVCodecContext* audio_codec_ctx, AVCodecContext* video_codec_ctx);
    std::vector<std::shared_ptr<Observer>> observers_; // 观察者列表
};
